Extend SUM_WITH_OVERFLOW reduction to signed integers and decimals - #22465

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@cpp/src/reductions/sum_with_overflow.cu`:
- Around line 129-133: The code currently treats an invalid init as if no init
was supplied; change the init handling in sum_overflow_result<DeviceType>
initial_value so that when init.has_value() is true you check
init.value().get().is_valid(stream) and if that check fails set
initial_value.valid = false (and do not seed initial_value.sum), otherwise seed
initial_value.sum from the scalar and set initial_value.valid = true; this makes
SUM_WITH_OVERFLOW propagate an invalid init to an invalid result consistent with
the other reductions (refer to symbols initial_value, sum_overflow_result,
init.value().get().is_valid).
- Around line 41-58: overflow_sum_op's operator() is not associative and
performs undefined signed overflow; fix by computing the combined sum in a safe,
well-defined wider or unsigned domain and deriving the overflow flag
deterministically so combination order doesn't matter: in
overflow_sum_op::operator(), when combining two sum_overflow_result<DeviceType>
values, first promote lhs.sum and rhs.sum to a wider integer type (or their
unsigned counterpart) or use a checked-add routine to compute a full-precision
result without invoking signed overflow, set overflow = lhs.overflow ||
rhs.overflow || (result out of DeviceType bounds), and store the
clamped/truncated DeviceType sum only after that safe check; also ensure that if
lhs.overflow or rhs.overflow is already true you do not perform a signed
addition on DeviceType (use the wider/unsigned accumulator or skip addition and
propagate a canonical value) so the combiner remains associative and avoids UB.

---

Nitpick comments:
In `@cpp/tests/reductions/reduction_tests.cpp`:
- Around line 3476-3707: Add tests for sliced and multi-block inputs to the
ReduceWithOverflowTest typed suite: create a sliced column (use
cudf::test::column_wrapper's slice or cudf::slice to produce a column with
non-zero offset) and run cudf::reduce(...) with
*cudf::make_sum_with_overflow_aggregation<reduce_aggregation>() to verify
correct sum and overflow extraction via
ReduceWithOverflowTest::extract_sum_overflow, and add a large column whose size
exceeds the backend block size (e.g., replicate a value to produce > block_size
elements) to exercise the parallel reduction path; also add analogous cases for
null-containing/sliced columns using make_null_col and for fixed_point types
(numeric::decimal32/64/128) so the typed suite covers offset handling and
multi-block reductions.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@cpp/include/cudf/reduction.hpp`:
- Around line 80-82: The documentation for the throw condition in
cudf::reduction (the comment describing std::invalid_argument for the
sum_with_overflow reduction) uses the wrong parameter name `output_dtype`;
update that identifier to the correct API parameter name `output_type` so the
doc matches the function signature and references `sum_with_overflow` and
`output_type` consistently.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Nitpick comments:
In `@cpp/src/reductions/sum_with_overflow.cu`:
- Around line 103-107: The temporaries overflow_scalar and the temporary columns
vector children (created via cudf::make_fixed_width_scalar and
cudf::make_column_from_scalar around sum_scalar and overflow_scalar) should be
allocated with cudf::get_current_device_resource_ref() instead of the passed-in
mr; change the allocator argument for these temporary allocations to
cudf::get_current_device_resource_ref() while still using the original mr for
the final struct_scalar return so only final output uses the caller-provided
memory resource.